Make @as part of the AST - #8619

Lambda's nine block and field builders each took a
Types.label_description and worked out the field's runtime name
themselves. The name is now decided once, when the label description is
built, and the builders take it as a plain string:

  -val fld_record : Types.label_description -> field_dbg_info
  +val fld_record : string -> field_dbg_info

so Lambda no longer reaches into Types or Typedtree to find out what a
field is called.

Note that typecore's dictionary path copies a label description with a
replaced name, so it has to replace the runtime name with it; otherwise
every dictionary field reads the name of the original.

Signed-off-by: Cristiano Calcagno <ccrisccris@gmail.com>

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01W8g8qwBARAcvW9MyuKQq8H

@as("x") renames a record field at run time. It was an attribute that
seven separate places re-read and re-interpreted: record construction
and access, record spread, record coercion, signature inclusion,
duplicate-field detection, the @tag conflict check, @deriving(abstract)
and gentype. The declaration now records the runtime name, and they all
read the same field.

Extraction happens in Ast_helper.Type.field, so the parser, every ppx
and the frozen-AST bridge inherit it: ast_mapper_from0 needs no change
at all, and ast_mapper_to0 puts the attribute back the way it already
does for pld_optional.

This removes the two hooks installed into Builtin_attributes to reach an
attribute reader from compiler/core, and the module that filled them.

@as keeps its surface syntax. The parsetree holds the literal with its
source spelling and its own location, so printers put it back exactly
where it was written; the typed tree holds only the decoded name, which
is what Asttypes.constant already does for every other string literal.
A payload that does not denote a name is left alone, and a second @as is
left for the type checker rather than rejected at parse time, so an
invalid file can still be formatted.

Signed-off-by: Cristiano Calcagno <ccrisccris@gmail.com>

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01W8g8qwBARAcvW9MyuKQq8H

Following the same move for record fields, a constructor's @as runtime
tag is now recorded on the declaration instead of being re-interpreted
from its attributes. Extraction happens in Ast_helper.Type.constructor,
so the parser, every ppx and the frozen-AST bridge inherit it, and
ast_mapper_to0 puts the attribute back the way it does for records.

The parsetree keeps the payload's source spelling, so @as(0xA) and
@as("A") print back as written rather than as 10 and "A". The typed
declaration keeps only the decoded tag.

This deletes process_tag_type, which decoded the same attribute a second
time, and with it four payload readers that had no other caller.
has_undefined_literal was dead. constructor_tag and block_runtime took
an attribute list that every caller passed empty, since they build tags
for constructors the compiler generates itself, so they now say that.

An out-of-range integer in @as used to abort the compiler with
Failure("int_of_string"); it now reports its own error at the
annotation.

Signed-off-by: Cristiano Calcagno <ccrisccris@gmail.com>

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01W8g8qwBARAcvW9MyuKQq8H

The seven cases a constructor's @as can state existed twice: once as
declared_tag, and again as seven of tag_type's eight constructors,
joined by a conversion. Nothing ever matched on declared_tag for a
decision; every use mapped it straight to tag_type. So tag_type now
holds the narrower type rather than repeating it, and the conversion
becomes the constructor:

  type tag_type = Literal of literal_tag | Untagged of block_type

Renamed from declared_tag, because two sites build the literal for a
constructor that declares nothing -- the default encoding is the
constructor's own name -- and because the surrounding code already calls
these literals: literal_tags, literal_cases, is_a_literal_case,
check_literal.

Functions that only ever handled literals now say so in their type:
js_exp_make's tag_type splits into the JS value a literal stands for and
the typeof string an untagged payload answers to, which were unrelated
jobs sharing one match, and printtyp's @as reconstruction takes a
literal_tag. Where a match arm per literal remains it unwraps Literal
once instead of in every arm, and variant_coercion's four arms that
differed only in the expected type become a table.

Signed-off-by: Cristiano Calcagno <ccrisccris@gmail.com>

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01W8g8qwBARAcvW9MyuKQq8H

A constructor's stored tag could only ever be a declared literal: the
untagged shape is synthesized during matching, at one place, from a
payload's block type. The record now says so, and the two roles get
separate names rather than one field standing for both:

  type tag = {name: string; literal: literal_tag option}
  type matchable_tag = {name: string; tag_type: tag_type option}

  val to_matchable_tag : tag -> matchable_tag

so constructor_tag returns a literal_tag option, literal_tags and
literal_cases are literal lists, and the coercion errors carry literals.
Their readers stop unwrapping a case that could not occur -- printtyp's
@as reconstruction loses its "should never happen" arm, and the overlap
predicates in the untagged checks stop matching on Untagged to answer
questions only a literal can answer.

Three functions had no callers. tag_can_be_undefined guarded the
optimisation removed in 244cdad, which compiled {field: VariantCase}
to field: VariantCase and made a single-case variant look exhaustive.
get_tag_name was a one-line wrapper that 108aa8f inlined past.
tag_type_to_user_visible_string is dead as of this commit: its Literal
branch delegated to literal_tag_to_user_visible_string, which is what
the narrowed errors call, and its Untagged branch was unreachable.

Signed-off-by: Cristiano Calcagno <ccrisccris@gmail.com>

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01W8g8qwBARAcvW9MyuKQq8H

Three functions read the single @as an item may carry, differing only in
the payload they accept: a string, an int, or any of int, string and
json. Each repeated the same skeleton -- find the attribute, reject a
second one, mark it used -- so that part is now written once and takes
the decoder:

  let as_string (attrs : t) : string option =
    single_as attrs ~decode:(fun ~loc payload ->
        match Ast_payload.semantic_string_of_payload payload with
        | None -> Bs_syntaxerr.err loc Expect_string_literal
        | Some v -> v)

The decoder runs before a second attribute is looked at, so a malformed
payload is still reported ahead of the duplicate that follows it rather
than the other way round.

Renamed from iter_process_bs_string_as and its siblings, which described
the traversal rather than the result and kept a bs prefix that no longer
means anything.

Signed-off-by: Cristiano Calcagno <ccrisccris@gmail.com>

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01W8g8qwBARAcvW9MyuKQq8H

iter_process_bs_string_int_unwrap_uncurry advertised uncurry, which it
does not handle, and omitted ignore, which it does. It answers which of
@string, @int, @ignore and @unwrap an external's argument carries, so it
is now arg_encoding.

Signed-off-by: Cristiano Calcagno <ccrisccris@gmail.com>

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01W8g8qwBARAcvW9MyuKQq8H

Every @as on a record field was marked used, which made sense when the
attribute was what the compiler read. Now the one that names the field
is taken out of the attributes when the field is built, so an @as still
there is either a second one, which the type checker rejects, or a
payload that is not a name at all.

@as(42) on a record field was accepted in silence: it renamed nothing
and nothing reported it. Only the attribute the compiler acts on is
marked now, so that case warns and a duplicate still reports just its
own error rather than both.

Signed-off-by: Cristiano Calcagno <ccrisccris@gmail.com>

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01W8g8qwBARAcvW9MyuKQq8H

Signed-off-by: Cristiano Calcagno <cristianoc@users.noreply.github.com>